1
00:00:00,540 --> 00:00:01,560
In der letzten Lektion

2
00:00:01,590 --> 00:00:05,880
Wir haben die Benutzeroberfläche für unseren Pomodoro-Timer fertiggestellt.

3
00:00:06,450 --> 00:00:11,130
und wir haben es geschafft, alle Komponenten, die wir benötigen, auf unseren grafischen Benutzer zu übertragen

4
00:00:11,130 --> 00:00:16,050
Schnittstelle. Der nächste Schritt besteht nun darin, ihm tatsächlich einige Funktionen zu verleihen.

5
00:00:16,770 --> 00:00:21,480
Ich möchte in der Lage sein, eine Art Countdown-Mechanismus zu erstellen, der einfach funktioniert

6
00:00:21,480 --> 00:00:24,000
etwas wirklich Einfaches. Zum Beispiel,

7
00:00:24,000 --> 00:00:28,830
Wenn es nur in der Lage wäre, von fünf, vier, drei, zwei herunterzuzählen,

8
00:00:29,220 --> 00:00:33,600
eins geht jedes Mal um eins zurück, das wäre großartig.

9
00:00:34,110 --> 00:00:36,420
Daran werden wir in dieser Lektion arbeiten.

10
00:00:36,480 --> 00:00:40,530
Und wir werden uns den Abschnitt zum Countdown-Mechanismus ansehen, um das zu tun.

11
00:00:41,490 --> 00:00:46,470
Eine Möglichkeit, dies anzugehen, besteht darin, unsere Zeit zu nutzen

12
00:00:46,470 --> 00:00:47,303
Modul

13
00:00:47,340 --> 00:00:52,020
Weil wir schon einmal gesehen haben, dass wir „time.sleep“ sagen und es auch sagen können

14
00:00:52,020 --> 00:00:53,550
eine Sekunde schlafen.

15
00:00:54,000 --> 00:00:58,980
Dann könnten wir vielleicht eine While-Schleife einrichten und während das eine oder andere wahr ist,

16
00:00:59,280 --> 00:01:04,260
Machen Sie weiter und schlafen Sie eine Sekunde lang. Und dann hinterher einfach,

17
00:01:04,320 --> 00:01:04,590
Du weißt schon,

18
00:01:04,590 --> 00:01:09,240
subtrahiere eins von einer Art Zähler. Damit wir um fünf mit dem Zählen beginnen konnten

19
00:01:09,240 --> 00:01:14,240
und dann subtrahieren wir jedes Mal um eins und jedes Mal aktualisieren wir einfach

20
00:01:15,360 --> 00:01:16,890
unser Label hier,

21
00:01:17,250 --> 00:01:21,750
die wir im Canvas erstellt haben, bis zu welcher Wertanzahl auch immer.

22
00:01:22,560 --> 00:01:24,990
Nun, das klingt im Prinzip großartig.

23
00:01:25,200 --> 00:01:30,200
Das einzige Problem ist, dass wir mit einer grafischen Benutzeroberfläche arbeiten

24
00:01:30,690 --> 00:01:31,523
Programm.

25
00:01:32,310 --> 00:01:36,750
Der Grund, warum das relevant ist, liegt darin, dass wir an eine Befehlszeile denken

26
00:01:36,750 --> 00:01:38,640
Programm, sagen wir zum Beispiel,

27
00:01:38,640 --> 00:01:43,020
Wenn wir unsere Konsole dazu bringen würden, etwas zu tun, drucken

28
00:01:43,080 --> 00:01:43,980
Hallo, na ja,

29
00:01:43,980 --> 00:01:48,980
Es wird nur dann etwas bewirken, wenn Sie ihm tatsächlich eine Anweisung geben und Sie

30
00:01:49,380 --> 00:01:50,213
Drücken Sie die Eingabetaste.

31
00:01:50,760 --> 00:01:55,530
Man muss nicht wirklich darauf achten, was man zwischendurch tun könnte.

32
00:01:56,130 --> 00:01:59,190
Eine grafische Benutzeroberfläche ist jedoch etwas anders.

33
00:01:59,520 --> 00:02:03,690
Es muss weiterhin auf den Bildschirm beobachtet werden, um festzustellen, ob

34
00:02:03,690 --> 00:02:06,870
wenn ein Benutzer beispielsweise auf eine Schaltfläche klickt.

35
00:02:07,350 --> 00:02:12,350
Es wird also grundsätzlich aktualisiert und weiterhin auf Ereignisse gewartet.

36
00:02:13,110 --> 00:02:14,880
Also jeden Bruchteil einer Sekunde,

37
00:02:14,880 --> 00:02:16,890
Es wird ständig überprüft, ob etwas passiert ist

38
00:02:16,920 --> 00:02:20,760
etwas ist passiert, ist etwas passiert? Und der Moment, in dem es passiert,

39
00:02:20,850 --> 00:02:24,510
dann muss es reagieren. Es muss auf dieses Ereignis reagieren.

40
00:02:25,050 --> 00:02:30,030
In diesem Fall neigen wir dazu, diese Art von GUI-Programmen als ereignisgesteuert zu bezeichnen.

41
00:02:30,690 --> 00:02:35,040
Und die Art und Weise, wie es angetrieben wird, erfolgt über unsere Hauptschleife.

42
00:02:35,490 --> 00:02:39,450
Wenn wir also unser Fenster einrichten und die Hauptschleife starten,

43
00:02:39,780 --> 00:02:44,780
Es ist im Grunde eine Schleife und prüft jede Millisekunde, ob es funktioniert hat

44
00:02:44,940 --> 00:02:47,730
etwas ist passiert, ist etwas passiert, ist etwas passiert?

45
00:02:48,210 --> 00:02:51,090
Das heißt also, wenn wir eine weitere Schleife in unserem Programm haben,

46
00:02:51,120 --> 00:02:55,200
es wird tatsächlich nicht in der Lage sein, die Hauptschleife zu erreichen. Und in diesem Fall,

47
00:02:55,230 --> 00:02:57,780
Wenn Sie tatsächlich versuchen, es auszuführen, passiert nichts.

48
00:02:57,840 --> 00:02:59,830
Unser Programm startet noch nicht einmal.

49
00:03:00,340 --> 00:03:05,260
Also müssen wir das überdenken und es ein bisschen anders machen. In

50
00:03:05,260 --> 00:03:08,950
um interaktive und interessante Programme zu erstellen,

51
00:03:09,370 --> 00:03:12,640
Es braucht irgendwie etwas, das auf dem Bildschirm passiert, oder?

52
00:03:12,640 --> 00:03:16,750
Hin und wieder. Sie benötigen diesen Timing-Mechanismus. Zum Glück,

53
00:03:16,780 --> 00:03:18,820
Daran hat tkinter bereits gedacht.

54
00:03:19,150 --> 00:03:23,800
Und wir können tatsächlich eine der integrierten Methoden für jedes Widget verwenden.

55
00:03:24,220 --> 00:03:26,140
Wenn wir also auf unser Fenster-Widget tippen,

56
00:03:26,290 --> 00:03:31,290
Wir können eine Methode erhalten, die nach und nach aufgerufen wird, was ganz einfach ist.

57
00:03:32,230 --> 00:03:36,760
Es ist eine Methode, die so viel Zeit in Anspruch nimmt, dass sie warten sollte

58
00:03:37,270 --> 00:03:39,190
und dann, nach dieser Zeitspanne,

59
00:03:39,460 --> 00:03:44,460
Es ruft einfach eine bestimmte Funktion auf, die Sie durch Übergabe einer beliebigen Funktion aufrufen sollen

60
00:03:44,650 --> 00:03:48,760
Argumente, die Sie ihm geben wollen. So funktioniert es.

61
00:03:48,820 --> 00:03:53,820
Wir rufen window.after auf und geben zunächst die Wartezeit an

62
00:03:54,460 --> 00:03:58,720
Millisekunden. Wenn wir also eine Sekunde wollen, dann sind das 1000 Millisekunden.

63
00:03:59,320 --> 00:04:02,200
Als nächstes übergeben wir eine aufzurufende Funktion.

64
00:04:02,530 --> 00:04:07,390
Also erstellen wir hier oben eine Funktion. Lass es uns einfach nennen, etwas sagen,

65
00:04:07,990 --> 00:04:10,330
und dann geben wir das Ding weiter,

66
00:04:12,610 --> 00:04:16,420
so. Und dann drucken wir das Ding nur noch aus.

67
00:04:16,960 --> 00:04:18,760
Also supereinfache Funktion.

68
00:04:18,790 --> 00:04:23,790
Und dann geben wir den Namen dieser Funktion als Funktion an, die nach 1000 aufgerufen werden soll

69
00:04:24,310 --> 00:04:25,143
Millisekunden.

70
00:04:25,600 --> 00:04:29,590
Nun zum Schluss dieser Liste von Argumenten:

71
00:04:29,920 --> 00:04:34,090
Wenn ich das einfach ausschneide und es Ihnen noch einmal zeige, wenn ich dazu aufgefordert werde,

72
00:04:34,510 --> 00:04:39,010
Das Letzte ist eigentlich ein *args.

73
00:04:39,490 --> 00:04:44,230
Wenn Sie sich erinnern, können wir dadurch eine unbegrenzte Anzahl eingeben

74
00:04:44,290 --> 00:04:46,090
von Positionsargumenten.

75
00:04:46,600 --> 00:04:50,890
Das bedeutet, dass wir so viele Argumente vorbringen können, wie wir wollen

76
00:04:51,220 --> 00:04:56,220
und diese Argumente werden in diesem Fall einfach an die Funktion übergeben

77
00:04:56,350 --> 00:04:59,920
das wir anrufen wollen. In diesem Fall wird es also dieses Ding sein.

78
00:05:00,190 --> 00:05:03,580
Wenn ich also hier „Hallo“ eingebe, führe ich meinen Code aus.

79
00:05:03,940 --> 00:05:07,990
Sie können sehen, dass nach 1000 Millisekunden, im Grunde einer Sekunde,

80
00:05:08,440 --> 00:05:10,750
es ruft diese Funktion auf,

81
00:05:10,810 --> 00:05:15,400
say_something, und es übergibt dieses Hallo als Eingabe

82
00:05:15,580 --> 00:05:18,370
zu dieser Funktion. Wie gesagt,

83
00:05:18,400 --> 00:05:22,000
Sie können unendlich viele Positionsargumente haben.

84
00:05:22,330 --> 00:05:26,530
Lassen Sie uns also einige andere Argumente einbringen, die wir als a bezeichnen:

85
00:05:26,530 --> 00:05:27,363
b und c,

86
00:05:27,610 --> 00:05:32,320
und dann drucken wir a, b und c aus.

87
00:05:33,970 --> 00:05:36,640
Und jetzt, anstatt Hallo zu sagen,

88
00:05:36,670 --> 00:05:41,650
Wir werden viele Positionsparameter übergeben. Also sagen wir 3, 5,

89
00:05:41,680 --> 00:05:44,500
und 8. Wenn ich jetzt „Run“ drücke,

90
00:05:44,560 --> 00:05:46,840
Sie werden sehen, dass es eine Sekunde wartet

91
00:05:47,170 --> 00:05:51,850
und dann übergibt es alle drei dieser Parameter, um etwas zu sagen

92
00:05:52,270 --> 00:05:55,480
und es geht weiter und druckt alle diese auf einmal aus.

93
00:05:56,050 --> 00:06:01,010
So funktioniert die After-Methode. Aber was wir tun wollten,

94
00:06:01,370 --> 00:06:03,920
Wollen wir, dass es sich wiederholt?

95
00:06:04,010 --> 00:06:09,010
im Wesentlichen eine Schleife bilden. Eine Möglichkeit, dieses Verhalten zu erreichen, besteht darin, es einfach auszudrücken

96
00:06:10,760 --> 00:06:11,240
Methode,

97
00:06:11,240 --> 00:06:16,240
Rufen Sie irgendwo innerhalb einer Funktion auf und rufen Sie sich dann selbst auf.

98
00:06:16,370 --> 00:06:20,930
Also hier ist, was ich meine. Lassen Sie uns eine Funktion namens count_down erstellen.

99
00:06:21,740 --> 00:06:26,740
und dies erfordert eine Eingabe in Form der Zahl, bis zu der heruntergezählt werden soll.

100
00:06:28,550 --> 00:06:32,270
Und dann rufen wir innerhalb dieser Funktion window.after auf.

101
00:06:32,720 --> 00:06:35,510
Und wir sagen, dass nach 1000 Millisekunden

102
00:06:35,750 --> 00:06:40,750
Rufen Sie diese Funktion count_down auf und übergeben Sie dann eine Zählnummer.

103
00:06:44,570 --> 00:06:47,390
Wenn diese Zählzahl mit 5 begann,

104
00:06:47,630 --> 00:06:50,840
dann wollen wir count - 1 sagen.

105
00:06:51,320 --> 00:06:55,700
Jetzt müssen wir nur noch diese Countdown-Methode aufrufen.

106
00:06:56,030 --> 00:07:00,530
Rufen wir also count_down auf und übergeben den Startzähler.

107
00:07:00,590 --> 00:07:04,430
sagen wir mal 5 Sekunden. Wenn ich jetzt den Code ausführe,

108
00:07:04,430 --> 00:07:07,760
Es wird diese Methode aufrufen und 5 hier übergeben.

109
00:07:08,300 --> 00:07:11,720
und dann wird es eine Sekunde warten,

110
00:07:12,110 --> 00:07:17,060
und dann wird diese Funktion count_down aufgerufen und fünf minus eins übergeben

111
00:07:17,240 --> 00:07:21,920
also wird es vier. Und dann wiederholt es sich noch einmal, wird zu drei,

112
00:07:21,950 --> 00:07:26,180
zwei, eins. Also, wenn wir jetzt diese Zahl fangen

113
00:07:26,360 --> 00:07:30,500
die wir ausdrucken können, dann können wir sehen, wie der Countdown abläuft

114
00:07:30,530 --> 00:07:34,190
wenn wir den Code ausführen; fünf, vier, drei,

115
00:07:34,580 --> 00:07:38,390
zwei, eins. Einer jede Sekunde,

116
00:07:38,450 --> 00:07:42,770
Und im Grunde geht es so weiter, und zwar bis hin zu den Negativen.

117
00:07:43,310 --> 00:07:46,310
Wenn wir also nicht wollen, dass die Zeit negativ wird,

118
00:07:46,340 --> 00:07:49,220
Dann müssen wir nur noch eine if-Anweisung hinzufügen.

119
00:07:49,640 --> 00:07:54,620
Wenn count größer als Null ist, fahren Sie fort und führen Sie diese Codezeile aus.

120
00:07:55,880 --> 00:07:59,780
Jetzt geht es also von fünf, vier, drei, zwei,

121
00:07:59,810 --> 00:08:02,570
Eins, Null, und dann hört es auf.

122
00:08:03,470 --> 00:08:08,450
Dies ist die Art von Verhalten, die wir benötigen würden, wenn wir unsere aktualisieren möchten

123
00:08:08,450 --> 00:08:11,180
Countdown in unserem Pomodoro-Timer.

124
00:08:11,900 --> 00:08:14,180
Wie können wir also statt drucken?

125
00:08:14,180 --> 00:08:19,180
Hat der Graf tatsächlich diesen Text auf unserer Leinwand verändert? Wir werden,

126
00:08:19,820 --> 00:08:24,820
Wir tun dies, indem wir diesem Text eine Variable zuweisen.

127
00:08:25,430 --> 00:08:28,460
Deshalb werde ich es timer_text nennen

128
00:08:29,870 --> 00:08:34,870
und jetzt haben wir timer_text als den Text festgelegt, der in erstellt wurde

129
00:08:35,360 --> 00:08:38,870
die Leinwand, dann können wir hier darauf zugreifen.

130
00:08:39,620 --> 00:08:44,120
Und die Art und Weise, wie wir einen Text oder etwas anderes in einem ändern würden

131
00:08:44,120 --> 00:08:48,110
Die Leinwand unterscheidet sich geringfügig von dem, was wir für ein Etikett tun würden.

132
00:08:48,530 --> 00:08:52,070
Wenn wir nur die Titelbezeichnung ändern wollten, würden wir title_ sagen

133
00:08:52,070 --> 00:08:56,310
label.config, und dann ändern wir den Text in etwas Neues.

134
00:08:56,940 --> 00:08:58,920
Aber um ein Canvas-Element zu ändern,

135
00:08:58,950 --> 00:09:02,640
Sie müssen tatsächlich auf die bestimmte Leinwand tippen, die Sie ändern möchten

136
00:09:03,240 --> 00:09:08,220
Dann rufen Sie eine Methode namens itemconfig auf. Und dann in dieser Methode,

137
00:09:08,280 --> 00:09:12,240
Sie übergeben das bestimmte Element, das Sie tatsächlich konfigurieren möchten.

138
00:09:12,540 --> 00:09:14,910
in unserem Fall ist es also der timer_text,

139
00:09:15,570 --> 00:09:20,570
und dann gibst du das an, was du eigentlich ändern möchtest

140
00:09:20,970 --> 00:09:24,300
Begriffe eines Kwarg, also ist dies ein Schlüsselwortargument.

141
00:09:24,870 --> 00:09:28,380
Wir werden den Text auf die aktuelle Anzahl ändern.

142
00:09:28,650 --> 00:09:31,620
Beachten Sie nun, dass dies nicht die Anzahl der Zeichenfolgen ist.

143
00:09:31,830 --> 00:09:34,290
denn dann würde es nur dieses Wort zeigen,

144
00:09:34,620 --> 00:09:39,270
aber es ist tatsächlich die Live-Countdown-Zeit. Zu diesem Zeitpunkt

145
00:09:39,300 --> 00:09:40,500
Wenn ich den Code ausführe,

146
00:09:40,500 --> 00:09:45,500
Ich erhalte tatsächlich eine Fehlermeldung, die uns mitteilt, dass der Name Canvas nicht definiert ist

147
00:09:46,320 --> 00:09:50,940
und das liegt daran, dass ich diese Methode „Countdown“ aufrufe, bevor ich sie tatsächlich erstellt habe

148
00:09:50,940 --> 00:09:51,690
die Leinwand.

149
00:09:51,690 --> 00:09:56,250
Wenn ich das also unter diese Linie verschiebe und es erneut ausführe,

150
00:09:56,280 --> 00:09:58,020
dann wirst du sehen, dass es tatsächlich funktioniert.

151
00:09:58,320 --> 00:10:02,370
Und Sie sehen, es beginnt bei fünf und zählt bis Null herunter.

152
00:10:03,180 --> 00:10:08,180
Wie können wir dieses Verhalten nun mit der Starttaste verknüpfen, damit ich die Taste drücken kann?

153
00:10:08,250 --> 00:10:13,140
Startknopf und dann, und nur dann, beginnt der Countdown von fünf,

154
00:10:13,140 --> 00:10:17,700
vier, drei, zwei, eins? Nun, lasst uns fortfahren und hinzufügen

155
00:10:17,760 --> 00:10:22,500
eine weitere Funktion und ich werde sie im Abschnitt Timer-Mechanismus hinzufügen und ich bin

156
00:10:22,500 --> 00:10:24,120
Ich werde es start_timer nennen.

157
00:10:24,900 --> 00:10:27,750
Jetzt ist diese Funktion supereinfach.

158
00:10:27,930 --> 00:10:32,930
Es wird lediglich für den Aufruf dieser Funktion verantwortlich sein

159
00:10:33,030 --> 00:10:36,660
Countdown und es wird von fünf Sekunden heruntergezählt.

160
00:10:36,810 --> 00:10:39,840
Also verschiebe ich das in den start_timer.

161
00:10:40,500 --> 00:10:45,500
Und jetzt ist der Starttimer die Funktion, die ausgelöst werden muss

162
00:10:47,070 --> 00:10:49,560
wenn der Startknopf gedrückt wird.

163
00:10:49,920 --> 00:10:53,280
Erinnern Sie sich, wie man eine Funktion mit einer Schaltfläche verknüpft?

164
00:10:53,280 --> 00:10:58,260
tkinter? Halten Sie das Video an und prüfen Sie, ob Sie diese Herausforderung lösen können

165
00:10:58,260 --> 00:11:03,260
Sie können den Code ausführen, auf Start klicken und den Timer starten, um den Countdown zu starten.

166
00:11:06,630 --> 00:11:11,630
Das Schlüsselwortargument ist also command und alles, was wir tun müssen, ist, es mit dem zu verknüpfen

167
00:11:12,210 --> 00:11:15,990
start_timer-Funktion, jedoch ohne Klammern.

168
00:11:16,500 --> 00:11:19,920
Wenn ich jetzt „Ausführen“ drücke und auf „Start“ klicke,

169
00:11:20,340 --> 00:11:24,840
Es startet den Timer und stellt den Text auf fünf, vier, drei,

170
00:11:24,930 --> 00:11:25,763
zwei, eins.

171
00:11:26,220 --> 00:11:31,220
Die Hauptschleife ist also das Abhören und die Interaktion des Benutzers mit der Starttaste

172
00:11:31,890 --> 00:11:36,660
Es ruft tatsächlich die Funktion start_timer auf, die wiederum die Funktion count_down aufruft

173
00:11:36,960 --> 00:11:39,900
und lassen Sie es von fünf Sekunden herunterzählen.

174
00:11:40,560 --> 00:11:43,980
Nun wollen wir eigentlich nicht von fünf Sekunden herunterzählen.

175
00:11:44,010 --> 00:11:48,750
Wir möchten in Minuten herunterzählen, da wir wahrscheinlich nicht arbeiten werden

176
00:11:48,750 --> 00:11:50,130
jeweils fünf Sekunden lang.

177
00:11:50,160 --> 00:11:54,040
Wir werden 25 Minuten arbeiten oder eine Minute Pause machen.

178
00:11:54,580 --> 00:11:59,580
Wie kann ich also diesen Countdown ändern, um ihn statt als fünf Sekunden zu interpretieren?

179
00:12:01,390 --> 00:12:04,990
bis fünf Minuten? Nun, lasst uns darüber nachdenken.

180
00:12:05,680 --> 00:12:09,850
Wenn wir herunterzählen wollten, sagen wir eine Minute,

181
00:12:10,240 --> 00:12:14,230
dann wären das in Sekunden ausgedrückt 60 Sekunden.

182
00:12:14,860 --> 00:12:18,670
Alles, was wir tun müssen, ist, die Anzahl der Minuten zu zählen, die wir herunterzählen möchten

183
00:12:18,670 --> 00:12:22,540
durch und multiplizieren Sie es mit 60. In diesem Fall:

184
00:12:22,540 --> 00:12:27,040
wenn wir es um fünf Minuten statt um fünf Sekunden herunterzählen wollten,

185
00:12:27,400 --> 00:12:30,160
Alles was wir tun müssen, ist mit 60 zu multiplizieren.

186
00:12:30,670 --> 00:12:33,880
Wenn wir also diese Funktion count_down aufrufen,

187
00:12:34,150 --> 00:12:36,790
Anstatt fünf Sekunden zum Countdown zu bekommen,

188
00:12:36,820 --> 00:12:39,190
Wir haben 300 Sekunden zum Zählen.

189
00:12:39,880 --> 00:12:44,470
Aber wenn wir jetzt unseren Code ausführen, können Sie sehen, dass er bei 300 beginnt.

190
00:12:44,740 --> 00:12:49,240
Es wird bis auf Null sinken. Was nun die Zeit betrifft,

191
00:12:49,390 --> 00:12:54,040
Das sind fünf Minuten, aber das ist keine sehr gute Möglichkeit, es sich vorzustellen.

192
00:12:54,370 --> 00:12:58,570
Niemand denkt an verbleibende 288 Sekunden, oder?

193
00:12:59,140 --> 00:13:04,140
Daher müssen wir diese Zählung formatieren, damit wir sie im Format anzeigen können

194
00:13:04,720 --> 00:13:09,010
00:00 wie die übliche Zeit, bei der zum Beispiel

195
00:13:09,010 --> 00:13:14,010
Sie haben noch eine Minute und 35 Sekunden oder so etwas in der Art.

196
00:13:15,520 --> 00:13:20,520
Wie können wir also so etwas schaffen? Wenn wir die Zählung in Bezug auf haben

197
00:13:20,680 --> 00:13:21,220
Sekunden,

198
00:13:21,220 --> 00:13:26,220
Nehmen wir also an, wir haben 300 und wir wollten wissen, wie viele Minuten darin enthalten sind

199
00:13:26,800 --> 00:13:31,800
dann müssen wir nur noch 300 nehmen und es dann durch 60 dividieren und wir erhalten

200
00:13:32,680 --> 00:13:37,150
5, das sind also 5 Minuten. Was aber, wenn der Countdown bereits läuft?

201
00:13:37,210 --> 00:13:42,210
und stattdessen hatten wir noch 245 Sekunden Zeit?

202
00:13:42,790 --> 00:13:43,000
Nun,

203
00:13:43,000 --> 00:13:48,000
Wir können tatsächlich herausfinden, wie viele Minuten und Sekunden das entspricht.

204
00:13:50,020 --> 00:13:54,430
Und das würden wir tun, indem wir diese Zahl nehmen, sagen wir 245,

205
00:13:54,760 --> 00:13:56,920
Teilen Sie es durch 60 Sekunden

206
00:13:57,280 --> 00:14:02,280
und wir würden eine Zahl 245/60 erhalten, die 4,08 ist,

207
00:14:05,440 --> 00:14:06,820
3 wiederkehrend.

208
00:14:07,570 --> 00:14:12,570
Wenn wir diese Zahl abrunden würden, um alle Dezimalstellen zu entfernen,

209
00:14:13,240 --> 00:14:16,060
dann wären das 4 Minuten.

210
00:14:16,810 --> 00:14:21,810
Und wenn wir dann wissen wollen, wie viele Sekunden es noch gibt, nachdem wir es geschafft haben

211
00:14:22,420 --> 00:14:23,620
Halten Sie die vier Minuten fest,

212
00:14:24,010 --> 00:14:29,010
Dann verwenden wir das Modulare, weil wir uns an das Modulare erinnern

213
00:14:29,650 --> 00:14:34,450
dividiert eine Zahl durch eine andere Zahl, also 245 dividiert durch 60,

214
00:14:34,870 --> 00:14:37,240
und dann wird es uns den Rest geben.

215
00:14:37,420 --> 00:14:42,280
Wie viel bleibt nach der sauberen Aufteilung übrig? Und in diesem Fall,

216
00:14:42,340 --> 00:14:47,340
Dies wäre tatsächlich die Anzahl der Sekunden, die nach den vier Minuten verbleiben

217
00:14:48,100 --> 00:14:51,650
wurde weggenommen. Schreiben wir also diesen Code aus.

218
00:14:52,550 --> 00:14:57,550
Die Zählminuten wären die Zählung dividiert durch 60,

219
00:14:59,780 --> 00:15:04,330
aber dann müssen wir es abrunden, damit wir den Rest loswerden.

220
00:15:04,330 --> 00:15:09,110
Jetzt wollen wir es nicht so runden, dass es etwa 3,6 wäre

221
00:15:09,170 --> 00:15:10,640
es wird 4.

222
00:15:10,910 --> 00:15:15,770
Eigentlich wollen wir einfach alles hinter dem Komma loswerden. Zu tun

223
00:15:15,770 --> 00:15:16,310
dass,

224
00:15:16,310 --> 00:15:21,310
Der einfachste Weg besteht darin, das Mathematikmodul zu importieren und dann eine Funktion namens Mathematik zu verwenden

225
00:15:23,870 --> 00:15:27,800
.floor und dieser math.floor,

226
00:15:27,830 --> 00:15:32,830
Wenn ich mit der Maus darüber fahre, wird die größte ganze Zahl zurückgegeben, die kleiner als ist

227
00:15:36,020 --> 00:15:37,310
oder gleich x.

228
00:15:37,790 --> 00:15:42,790
Wenn dies eine 4,8 war, dann ist die größte Lochzahl kleiner als 4,8 4.

229
00:15:46,250 --> 00:15:47,960
Das ist also im Grunde das, was dies bewirken wird.

230
00:15:48,170 --> 00:15:51,020
Und das gibt uns die Anzahl der Minuten. Nun,

231
00:15:51,020 --> 00:15:53,000
Das nächste, was wir tun wollen, ist zu wissen, nun ja,

232
00:15:53,000 --> 00:15:58,000
Wie viele Sekunden verbleiben, nachdem wir die Minuten abgezogen haben? Um dies zu tun,

233
00:15:58,700 --> 00:15:59,660
Wir werden zählen

234
00:15:59,720 --> 00:16:03,200
und dann werden wir das Modulo verwenden, um es durch 60 zu dividieren.

235
00:16:03,770 --> 00:16:08,770
Das Modulo gibt uns also die verbleibende Anzahl an Sekunden, nachdem wir es getan haben

236
00:16:09,440 --> 00:16:12,650
Teilen Sie es sauber durch 600. Zum Beispiel:

237
00:16:12,650 --> 00:16:16,250
Wenn wir 100 Sekunden hätten und diese durch 60 teilen würden, nun ja,

238
00:16:16,250 --> 00:16:17,870
das wird gleich eins sein.

239
00:16:18,290 --> 00:16:23,290
Wir können also von 100 60 abziehen und erhalten als Rest 40.

240
00:16:25,010 --> 00:16:27,830
Das ist es, was wir erhalten, nachdem wir das Modulo durchgeführt haben.

241
00:16:28,430 --> 00:16:31,220
Das ist also im Grunde die Anzahl der verbleibenden Sekunden.

242
00:16:32,240 --> 00:16:36,260
Da wir nun die Minute und die Sekunde haben, können wir das tatsächlich ändern

243
00:16:36,260 --> 00:16:41,260
count, um einen F-String zu verwenden, und wir können ihn so formatieren, dass wir die Zählminute hinzufügen

244
00:16:42,170 --> 00:16:43,003
Erstens,

245
00:16:43,130 --> 00:16:48,130
und dann fügen wir einen Doppelpunkt und dann unsere Zählung in Sekunden hinzu.

246
00:16:49,430 --> 00:16:53,900
Schauen Sie sich nun an, was passiert. Wir werden versuchen, fünf Minuten herunterzuzählen.

247
00:16:54,260 --> 00:16:58,490
Also ermitteln wir die Anzahl der Sekunden und übergeben sie an diese Funktion.

248
00:16:58,880 --> 00:17:03,080
Wir berechnen, was die Zählung in Minuten und Sekunden entspricht

249
00:17:03,470 --> 00:17:06,920
und danach subtrahieren wir jedes Mal eine Sekunde.

250
00:17:07,520 --> 00:17:10,310
Wenn ich jetzt den Code ausführe und auf Start klicke,

251
00:17:10,640 --> 00:17:14,270
Beachten Sie, wie es bei 5 Minuten beginnt und auf 4 Minuten abfällt.

252
00:17:14,270 --> 00:17:15,980
50, 59,

253
00:17:16,070 --> 00:17:19,310
und dann läuft es wie ein echter Timer weiter.

254
00:17:20,180 --> 00:17:21,440
Das ist ziemlich cool.

255
00:17:21,650 --> 00:17:26,650
Jetzt müssen wir nur noch herausfinden, wie wir es erreichen können, dass nicht 5:0 angezeigt wird.

256
00:17:27,350 --> 00:17:32,060
Wie können wir erreichen, dass 5:00 angezeigt wird?

257
00:17:32,840 --> 00:17:36,260
wie man es auf einer Uhr sehen würde? Um herauszufinden, wie das geht

258
00:17:36,290 --> 00:17:39,170
Wir müssen etwas über die dynamische Typisierung in Python lernen.

259
00:17:39,440 --> 00:17:43,370
Wir müssen verstehen, wie das funktioniert, und darüber werden wir sprechen

260
00:17:43,370 --> 00:17:46,340
darüber in der nächsten Lektion. Also wir sehen uns dort.

